import numpy as np

# imports
import pytest  # used for our unit tests
from matplotlib.colors import rgb_to_hsv

# --------------------- Basic Test Cases ---------------------


def test_invalid_shape_last_dim_not_3():
    # Input shape (..., 2) should raise ValueError
    rgb = [1, 0]
    with pytest.raises(ValueError):
        rgb_to_hsv(rgb)  # 9.48μs -> 9.49μs (0.084% slower)


def test_invalid_shape_high_dim():
    # Input shape (..., 4) should raise ValueError
    rgb = [[1, 0, 0, 0]]
    with pytest.raises(ValueError):
        rgb_to_hsv(rgb)  # 9.85μs -> 9.82μs (0.224% faster)


def test_empty_input():
    # Empty input with shape (0, 3) should return empty output
    rgb = np.empty((0, 3))
    codeflash_output = rgb_to_hsv(rgb)
    result = codeflash_output  # 75.8μs -> 71.4μs (6.06% faster)


def test_input_with_nan():
    # Input with NaN should propagate NaN in output
    rgb = [np.nan, 0, 1]
    codeflash_output = rgb_to_hsv(rgb)
    result = codeflash_output  # 80.9μs -> 80.5μs (0.486% faster)


def test_input_with_negative_values():
    # Negative values are allowed by numpy but not in [0,1] range; function does not check, so it should compute
    rgb = [-0.5, 0.5, 0.5]
    # The output should be deterministic and not crash
    codeflash_output = rgb_to_hsv(rgb)
    result = codeflash_output  # 89.8μs -> 84.6μs (6.17% faster)


def test_input_with_values_above_one():
    # Values above 1 are not checked; should compute without error
    rgb = [1.5, 1, 0.5]
    codeflash_output = rgb_to_hsv(rgb)
    result = codeflash_output  # 82.0μs -> 78.8μs (4.10% faster)


def test_input_1d_array():
    # 1D array input should be accepted
    rgb = np.array([0.2, 0.4, 0.6])
    codeflash_output = rgb_to_hsv(rgb)
    result = codeflash_output  # 82.1μs -> 78.2μs (5.09% faster)


def test_large_batch_of_colors():
    # Test with a large batch of random RGB colors
    np.random.seed(42)
    rgb = np.random.rand(1000, 3)
    codeflash_output = rgb_to_hsv(rgb)
    result = codeflash_output  # 248μs -> 140μs (76.6% faster)


def test_large_batch_performance():
    # Test that the function runs efficiently on a large batch
    rgb = np.random.rand(999, 3)
    codeflash_output = rgb_to_hsv(rgb)
    result = codeflash_output  # 246μs -> 141μs (74.1% faster)


def test_large_multidimensional_array():
    # Test with a large 3D array
    rgb = np.random.rand(10, 10, 10, 3)
    codeflash_output = rgb_to_hsv(rgb)
    result = codeflash_output  # 277μs -> 147μs (88.3% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import numpy as np

# imports
import pytest  # used for our unit tests
from matplotlib.colors import rgb_to_hsv

# unit tests


# Helper to compare HSV values with tolerance for floating point errors
def assert_hsv_close(actual, expected, tol=1e-7):
    actual = np.asarray(actual)
    expected = np.asarray(expected)


# ---------------------------
# 1. BASIC TEST CASES
# ---------------------------


def test_shape_error():
    # Input with wrong shape (not (...,3)), should raise ValueError
    with pytest.raises(ValueError):
        rgb_to_hsv([1, 0])  # 8.60μs -> 8.57μs (0.315% faster)

    with pytest.raises(ValueError):
        rgb_to_hsv(
            [[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 1, 0]]
        )  # 3.59μs -> 3.90μs (7.96% slower)


def test_1d_input():
    # Accepts 1D input of length 3
    codeflash_output = rgb_to_hsv([0.1, 0.2, 0.3])
    result = codeflash_output  # 87.1μs -> 82.3μs (5.83% faster)
    # max=0.3, min=0.1, delta=0.2, V=0.3, S=0.2/0.3=0.666...
    # B is max, H = 4 + (0.1-0.2)/0.2 = 4 - 0.5 = 3.5/6 = 0.583333...
    expected = [0.5833333333333334, 2 / 3, 0.3]
    assert_hsv_close(result, expected)


def test_dtype_int():
    # Accepts integer input, but converts to float
    arr = np.array([255, 0, 0])
    arr = arr / 255.0
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 74.7μs -> 69.7μs (7.17% faster)
    assert_hsv_close(result, [0, 1, 1])


def test_dtype_uint8():
    # Accepts uint8 input, but converts to float
    arr = np.array([255, 255, 0], dtype=np.uint8)
    arr = arr / 255.0
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 73.7μs -> 69.3μs (6.30% faster)
    assert_hsv_close(result, [1 / 6, 1, 1])


def test_zero_saturation():
    # Test for color with zero saturation (gray)
    arr = [0.4, 0.4, 0.4]
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 78.0μs -> 74.8μs (4.23% faster)
    # H is undefined, but should be 0, S=0, V=0.4
    assert_hsv_close(result, [0, 0, 0.4])


def test_near_zero_delta():
    # Test for color with very small delta
    arr = [0.500001, 0.5, 0.5]
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 80.4μs -> 77.1μs (4.33% faster)
    # Should be very close to gray, H=0, S ~0.000002/0.500001, V=0.500001
    expected = [0, (0.500001 - 0.5) / 0.500001, 0.500001]
    assert_hsv_close(result, expected)


def test_negative_values():
    # Negative values should not be clipped, but will produce out-of-range HSV
    arr = [-0.1, 0.2, 0.3]
    # max=0.3, min=-0.1, delta=0.4, V=0.3, S=0.4/0.3=1.333...
    # B is max, H = 4 + (-0.1-0.2)/0.4 = 4 - 0.75 = 3.25/6 = 0.541666...
    expected = [0.5416666666666666, 1.3333333333333333, 0.3]
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 81.2μs -> 76.7μs (5.89% faster)
    assert_hsv_close(result, expected)


def test_above_one_values():
    # Values above 1 should not be clipped, but will produce V>1
    arr = [1.2, 0.6, 0.6]
    # max=1.2, min=0.6, delta=0.6, V=1.2, S=0.6/1.2=0.5
    # R is max, H=(0.6-0.6)/0.6=0, H=0/6=0
    expected = [0, 0.5, 1.2]
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 79.8μs -> 75.4μs (5.85% faster)
    assert_hsv_close(result, expected)


def test_input_with_nan():
    # Test input with NaN
    arr = [np.nan, 0.5, 0.5]
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 82.5μs -> 79.9μs (3.36% faster)


def test_preserve_shape_nd():
    # Test that shape is preserved for nD input
    arr = np.ones((2, 3, 3))
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 83.8μs -> 77.1μs (8.76% faster)


def test_empty_input():
    # Empty input with shape (0,3) should return empty output
    arr = np.empty((0, 3))
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 68.9μs -> 65.2μs (5.78% faster)


# ---------------------------
# 3. LARGE SCALE TEST CASES
# ---------------------------


def test_large_batch():
    # Test with a large batch of colors (1000,3)
    arr = np.random.rand(1000, 3)
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 242μs -> 137μs (77.0% faster)


def test_large_nd_batch():
    # Test with a large nD batch (10, 10, 10, 3)
    arr = np.random.rand(10, 10, 10, 3)
    codeflash_output = rgb_to_hsv(arr)
    result = codeflash_output  # 273μs -> 146μs (86.6% faster)


def test_performance_large_batch(benchmark):
    # Benchmark performance on a large batch
    arr = np.random.rand(1000, 3)
    benchmark(rgb_to_hsv, arr)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.